﻿#define  _CRT_SECURE_NO_WARNINGS 1

//#include<iostream>
//using namespace std;
//
//int main()
//{
//	int i = 0;
//	cout << "xxx" << i << '\n' << endl;
//	printf("%d\n", i);
//
//	return 0;
//}

//#include<iostream>
//using namespace std;
//
//int main()
//{
//	// 在io需求比较高的地方，如部分大量输入的竞赛题中，加上以下3行代码
//	// 可以提高C++IO效率
//	ios_base::sync_with_stdio(false);
//	cin.tie(nullptr);
//	cout.tie(nullptr);
//
//	return 0;
//}

//#include<iostream>
//using namespace std;
//
//void Func(int a = 0)//赋予参数值，此为缺省值，a为缺省参数
//{
//	cout << a << endl;
//}
//
//int main()
//{
//	Func(); // 没有传参时，使⽤参数的默认值 
//	Func(10); // 传参时，使⽤指定的实参 
//	return 0;
//}

//#include<iostream>
//using namespace std;
//// 全缺省
//void Func1(int a = 10, int b = 20, int c = 30)
//{
//	cout << "a = " << a << endl;
//	cout << "b = " << b << endl;
//	cout << "c = " << c << endl << endl;
//}
//
//int main()
//{
//	Func1(1, 2, 3);
//	Func1(1, 2);
//	Func1(1);
//	Func1();
//
//	return 0;
//}

//#include<iostream>
//using namespace std;
//// 半缺省
//void Func2(int b, int c = 20, int a = 10)
//{
//	cout << "a = " << a << endl;
//	cout << "b = " << b << endl;
//	cout << "c = " << c << endl << endl;
//}
//
//int main()
//{
//	Func2(1);
//	Func2(1, 2);
//	Func2(1, 2, 3);
//
//	return 0;
//}

////函数重载
//#include<iostream>
//using namespace std;
////1.参数类型不同
//int Add(int left, int right)
//{
//	cout << "int Add(int left, int right)" << endl;
//	return left + right;
//}
//double Add(double left, double right)
//{
//	cout << "double Add(double left, double right)" << endl;
//	return left + right;
//}
//
//int main()
//{
//	cout << Add(1, 2) << endl;
//	cout << Add(1.1, 2.2) << endl;
//	return 0;
//}

////2.参数个数不同
//#include<iostream>
//using namespace std;
//
//void f()
//{
//	cout << "f()" << endl;
//}
//void f(int a)//1个int参数
//{
//	cout << "f(int a)" << endl;
//}
//
//int main()
//{
//	f();
//	f(10);
//	return 0;
//}

////3.参数类型顺序不同 
//#include<iostream>
//using namespace std;
//
//void f(int a, char b)
//{
//	cout << "f(int a,char b)" << endl;
//}
//void f(char b, int a)
//{
//	cout << "f(char b, int a)" << endl;
//}
//
//int main() {
//    f(10, 'A');   // 调用参数为「int, char」的版本
//    f('B', 20);   // 调用参数为「char, int」的版本
//    return 0;
//}

//#include<iostream>
//using namespace std;
//
//// 返回值不同不能作为重载条件，因为调⽤时也⽆法区分 
//void fxx()
//{
//	return 0;
//}
//int fxx()
//{
// return 0;
//}
//
//int main()
//{
//	// 调用时无法确定要调用哪个
//	fxx();
//	
//	return 0;
//}

//#include<iostream>
//using namespace std;
//
//void f1()
//{
//	cout << "f()" << endl;
//}
//
//void f1(int a = 10)
//{
//	cout << "f(int a)" << endl;
//}
//int main()
//{
//	//f1(1);
//	f1();
//}

//#include<iostream>
//using namespace std;
//
//int main()
//{
//	int a = 0;
//	// 引⽤：b和c是a的别名 
//	int& b = a;
//	int& c = a;
//	// 也可以给别名b取别名，d相当于还是a的别名 
//	int& d = b;
//	++d;
//	// 这⾥取地址我们看到是⼀样的 
//	cout << &a << endl;
//	cout << &b << endl;
//	cout << &c << endl;
//	cout << &d << endl;
//	return 0;
//}

//#include<iostream>
//using namespace std;
//
//int main()
//{
//	int i = 1;
//	int& j = i;
//
//	cout << &i << endl;
//	cout << &j << endl;
//
//	++j;
//
//	// 一个变量可以有多个引用
//	int& k = j;
//
//	k = 10;
//
//	// 引用在定义时必须初始化
//	 /*int& x;
//	 x = i;*/
//
//	// 引用一旦引用一个实体，再不能引用其他实体
//	int m = 20;
//	k = m;
//
//	return 0;
//}

#include<iostream>
using namespace std;

//// 指针
//// 引用
//// 大部分场景去替代指针，部分场景还是离不开指针
//
//void Swap(int* rx, int* ry)
//{
//	int tmp = *rx;
//	*rx = *ry;
//	*ry = tmp;
//}
//
//void Swap(int& rx, int& ry)
//{
//	int tmp = rx;
//	rx = ry;
//	ry = tmp;
//}
//
//int main()
//{
//	int x = 0, y = 1;
//	cout << x << " " << y << endl;
//
//	// Swap(&x, &y);
//	cout << x << " " << y << endl;
//
//	Swap(x, y);
//	cout << x << " " << y << endl;
//
//	return 0;
//}
//

typedef struct SeqList
{
	//...
}SL;

//void SLInit(SL* psl, int n = 4)
void SLInit(SL& psl, int n = 4)
{
	//...
}

void Swap(int** pp1, int** pp2)
{
	int* tmp = *pp1;
	*pp1 = *pp2;
	*pp2 = tmp;
}

void Swap(int*& rp1, int*& rp2)
{
	int* tmp = rp1;
	rp1 = rp2;
	rp2 = tmp;
}

//int main()
//{
//	int x = 0, y = 1;
//	cout << x << " " << y << endl;
//
//	// Swap(&x, &y);
//	cout << x << " " << y << endl;
//
//	Swap(x, y);
//	cout << x << " " << y << endl;
//
//	return 0;
//}


//typedef struct SListNode
//{
//	struct SListNode* next;
//	int val;
//}SLTNode, *PSLTNode;
//
//typedef struct SListNode SLTNode;
//typedef struct SListNode* PSLTNode;
//
//
////void SLTPushBack(SLTNode** pphead, int x)
////{
////	SLTNode* newnode; // = malloc
////
////	if (*pphead == NULL)
////	{
////		*pphead = newnode;
////	}
////	else
////	{
////		// 找到尾结点，newnode链接到尾结点
////	}
////}
//
////void SLTPushBack(SLTNode*& phead, int x)
//void SLTPushBack(PSLTNode& phead, int x)
//{
//	SLTNode* newnode = NULL; // = malloc
//
//	if (phead == NULL)
//	{
//		phead = newnode;
//	}
//	else
//	{
//		// 找到尾结点，newnode链接到尾结点
//	}
//}
//
//int main()
//{
//	int x = 0, y = 1;
//	cout << x << " " << y << endl;
//
//	// Swap(&x, &y);
//	cout << x << " " << y << endl;
//
//	Swap(x, y);
//	cout << x << " " << y << endl;
//
//	SL s;
//	SLInit(s);
//
//	int* p1 = &x, *p2 = &y;
//	Swap(&p1, &p2);
//	Swap(p1, p2);
//
//	//SLTNode* plist = NULL;
//	//SLTPushBack(&plist, 1);
//	//SLTPushBack(&plist, 2);
//	//SLTPushBack(&plist, 3);
//	//SLTPushBack(&plist, 4);
//
//	//SLTNode* plist = NULL;
//	PSLTNode plist = NULL;
//	SLTPushBack(plist, 1);
//	SLTPushBack(plist, 2);
//	SLTPushBack(plist, 3);
//	SLTPushBack(plist, 4);
//
//	return 0;
//}

////传引用返回
//int func()
//{
//	int ret = 0;
//	// ...
//	return ret;
//}
//
//int main()
//{
//	int x = func();
//	return 0;
//}

//// 传引用返回
//int& func()
//{
//	int ret = 0;
//	// ...
//	return ret;
//}
//
//int main()
//{
//	int x = func();
//	cout << x << endl;
//	int a[10];
//	// 越界抽查
//	a[10] = 1;
//	a[11] = 1;
//	a[15] = 1;
//	return 0;
//}

//int& func1()
//{
//	//static int ret = 0;
//	int ret = 0;
//	// ...
//	return ret;
//}
//
//int& func2()
//{
//	int y = 456;
//	// ...
//	return y;
//}
//
//int main()
//{
//	int& x = func1();
//	cout << x << endl;
//	func2();
//	cout << x << endl;
//
//	return 0;
//}

//#include"seqList.h"
//
//int main()
//{
//	SL s;
//	SLInit(&s, 10);
//	for (size_t i = 0; i < 10; i++)
//	{
//		SLPushBack(&s, i);
//	}
//
//	for (size_t i = 0; i < 10; i++)
//	{
//		cout << SLat(&s, i) << " ";
//	}
//	cout << endl;
//
//	// 修改顺序表第i个位置的值
//	int i = 0, x = 0;
//	cin >> i;
//	cin >> x;
//	//SLModify(&s, i, x);
//	SLat(&s, i) = x;
//
//	for (size_t i = 0; i < 10; i++)
//	{
//		cout << SLat(&s, i) << " ";
//	}
//	cout << endl;
//
//	return 0;
//}
//
//int main()
//{
//	int i = 0;
//	// 语法引用不开空间，指针要开空间
//	int& r1 = i;
//	int* p = &i;
//
//	r1++;
//	(*p)++;
//
//	return 0;
//}


#include<iostream>
using namespace std;

//int main()
//{
//	//int a = 0;
//	const int a = 10;
//	// 编译报错：error C2440: “初始化”: ⽆法从“const int”转换为“int &” 
//	// 这⾥的引⽤是对a访问权限的放⼤ 
//
//	const int& b = a;
//	return 0;
//}

//int main()
//{
//	const int a = 10;
//	
//	const int& b = a;
//
//	int c = 0;
//	//权限缩小
//	const int& d = c;
//
//	return 0;
//}

//int main()
//{
//	const int a = 0;
//	//不能权限放大
//	//int& b = a;
//
//	//不是权限放大，是拷贝赋值
//	int e = a;
//	const int& b = a;
//
//	int c = 0;
//	//权限缩小
//	const int& d = c;
//
//	return 0;
//}

//int main()
//{
//	const int a = 0;
//	const int* p1 = &a;
//	//不能权限放大
//	//int* p2 = p1;
//	const int* p2 = p1;
//
//	//可以权限缩小
//	int e = a;
//	int* p3 = &e;
//	const int* p4 = p3;
//	return 0;
//}

//void func(const int& x)//可以减少拷贝，可以传普通对象
//{
//
//}
//
//int main()
//{
//	//const int& a = 10;
//	int y = 0;
//	func(y);
//
//	const int z = 1;
//	func(z);
//	func(2);
//
//	double d = 2.2;
//	func(d);
//
//	return 0;
//}

//int main()
//{
//	int i = 1;
//	double d = i;
//
//	int p = (int)&i;
//
//	const double& rd = i;
//	const int& rp = (int)&i;
//
//	return 0;
//}

////宏是一种替换机制
////错误一：
//#define ADD(int a, int b) return a + b;
////错误二：
//#define ADD(a, b) a + b;//后面加了分号，主函数中ret2不能运行
////错误三：
//#define ADD(a, b) a + b//影响优先级，主函数中ret2运行错误
////错误四：
//#define ADD(a, b) (a + b)
////正确：
//#define ADD(a, b) ((a) + (b))
//
//// 宏函数很复杂，容易写出问题，还不能调试
//// 优点：高频调用小函数，写成宏函数，可以提高效率，预处理阶段宏会替换，提高效率，不建立栈帧
//int main()
//{
//	int ret1 = ADD(1, 2); // 被替换为int ret1 = 1+2;;
//	cout << ret1 << endl;
//
//	int ret2 = ADD(1, 2)*3;
//	cout << ret2 << endl;
//
//	// a和b是表达式，表达式中的运算符比+优先级低
//	int x = 0, y = 1;
//	ADD(x | y, x & y); //如果不加括号： ((x|y) + (x&y));
//
//	return 0;
//}


//inline int Add(int x, int y)
//{
//	return x + y;
//}
//
//int main()
//{
//	int ret = Add(1, 2) * 3;
//	cout << ret << endl;
//
//	int x = 0, y = 1;
//	Add(x | y, x & y);
//
//	return 0;
//}

//inline int Add(int x, int y)
//{
//	return x + y;
//}
//
//int main()
//{
//	int ret = Add(1, 2) * 3;
//	cout << ret << endl;
//
//	return 0;
//}

//#include"SeqList.h"
//
//int main()
//{
//	SL s;
//	SLInit(&s); // call 地址
//
//
//	return 0;
//}

//void f(int x)
//{
//	cout << "f(int x)" << endl;
//}
//
//void f(int* ptr)
//{
//	cout << "f(int* ptr)" << endl;
//}
//
//int main()
//{
//	f(0);
//	// 本想通过f(NULL)调⽤指针版本的f(int*)函数，但是由于NULL被定义成0，调⽤了f(int 
//	//x)，因此与程序的初衷相悖。
//	f(NULL);
//	//f((void*)0);
//	// 编译报错：error C2665: “f”: 2 个重载中没有⼀个可以转换所有参数类型 
//
//	int* p1 = NULL;
//	char* p2 = NULL;
//
//	return 0;
//}

void f(int x)
{
	cout << "f(int x)" << endl;
}

void f(int* ptr)
{
	cout << "f(int* ptr)" << endl;
}

int main()
{
	f(0);
	f(NULL);
	//f((void*)0);
	f(nullptr);

	int* p1 = NULL;
	char* p2 = NULL;

	int* p3 = nullptr;//int*
	char* p4 = nullptr;//char*

	return 0;
}